int CSciContext::AddText(CValue** ppParams)
{
	int length=ppParams[0]->GetNumeric();
	const char* text=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_ADDTEXT, length, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::AddStyledText(CValue** ppParams)
{
	int length=ppParams[0]->GetNumeric();
	const char* c=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_ADDSTYLEDTEXT, length, reinterpret_cast<LPARAM>(c));
	return TRUE;
}

int CSciContext::InsertText(CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	const char* text=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_INSERTTEXT, pos, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::ClearAll(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CLEARALL, 0, 0);
	return TRUE;
}

int CSciContext::ClearDocumentStyle(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CLEARDOCUMENTSTYLE, 0, 0);
	return TRUE;
}

int CSciContext::GetLength(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLENGTH, 0, 0);
	return TRUE;
}

int CSciContext::GetCharAt(CValue& retVal, CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCHARAT, pos, 0);
	return TRUE;
}

int CSciContext::GetCurrentPos(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCURRENTPOS, 0, 0);
	return TRUE;
}

int CSciContext::GetAnchor(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETANCHOR, 0, 0);
	return TRUE;
}

int CSciContext::GetStyleAt(CValue& retVal, CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSTYLEAT, pos, 0);
	return TRUE;
}

int CSciContext::Redo(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_REDO, 0, 0);
	return TRUE;
}

int CSciContext::SetUndoCollection(CValue** ppParams)
{
	BOOL collectUndo=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETUNDOCOLLECTION, collectUndo, 0);
	return TRUE;
}

int CSciContext::SelectAll(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_SELECTALL, 0, 0);
	return TRUE;
}

int CSciContext::SetSavePoint(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_SETSAVEPOINT, 0, 0);
	return TRUE;
}

int CSciContext::GetStyledText(CValue& retVal, CValue** ppParams)
{
	const char* tr=ppParams[0]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSTYLEDTEXT, 0, reinterpret_cast<LPARAM>(tr));
	return TRUE;
}

int CSciContext::CanRedo(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_CANREDO, 0, 0);
	return TRUE;
}

int CSciContext::MarkerLineFromHandle(CValue& retVal, CValue** ppParams)
{
	int handle=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_MARKERLINEFROMHANDLE, handle, 0);
	return TRUE;
}

int CSciContext::MarkerDeleteHandle(CValue** ppParams)
{
	int handle=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_MARKERDELETEHANDLE, handle, 0);
	return TRUE;
}

int CSciContext::GetUndoCollection(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETUNDOCOLLECTION, 0, 0);
	return TRUE;
}

int CSciContext::GetViewWS(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETVIEWWS, 0, 0);
	return TRUE;
}

int CSciContext::SetViewWS(CValue** ppParams)
{
	int viewWS=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETVIEWWS, viewWS, 0);
	return TRUE;
}

int CSciContext::PositionFromPoint(CValue& retVal, CValue** ppParams)
{
	int x=ppParams[0]->GetNumeric();
	int y=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_POSITIONFROMPOINT, x, y);
	return TRUE;
}

int CSciContext::PositionFromPointClose(CValue& retVal, CValue** ppParams)
{
	int x=ppParams[0]->GetNumeric();
	int y=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_POSITIONFROMPOINTCLOSE, x, y);
	return TRUE;
}

int CSciContext::GotoLine(CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_GOTOLINE, line, 0);
	return TRUE;
}

int CSciContext::GotoPos(CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_GOTOPOS, pos, 0);
	return TRUE;
}

int CSciContext::SetAnchor(CValue** ppParams)
{
	long posAnchor=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETANCHOR, posAnchor, 0);
	return TRUE;
}


int CSciContext::GetEndStyled(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETENDSTYLED, 0, 0);
	return TRUE;
}

int CSciContext::ConvertEOLs(CValue** ppParams)
{
	int eolMode=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_CONVERTEOLS, eolMode, 0);
	return TRUE;
}

int CSciContext::GetEOLMode(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETEOLMODE, 0, 0);
	return TRUE;
}

int CSciContext::SetEOLMode(CValue** ppParams)
{
	int eolMode=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETEOLMODE, eolMode, 0);
	return TRUE;
}

int CSciContext::StartStyling(CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	int mask=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STARTSTYLING, pos, mask);
	return TRUE;
}

int CSciContext::SetStyling(CValue** ppParams)
{
	int length=ppParams[0]->GetNumeric();
	int style=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSTYLING, length, style);
	return TRUE;
}

int CSciContext::GetBufferedDraw(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETBUFFEREDDRAW, 0, 0);
	return TRUE;
}

int CSciContext::SetBufferedDraw(CValue** ppParams)
{
	BOOL buffered=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETBUFFEREDDRAW, buffered, 0);
	return TRUE;
}

int CSciContext::SetTabWidth(CValue** ppParams)
{
	int tabWidth=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETTABWIDTH, tabWidth, 0);
	return TRUE;
}

int CSciContext::GetTabWidth(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETTABWIDTH, 0, 0);
	return TRUE;
}

int CSciContext::SetCodePage(CValue** ppParams)
{
	int codePage=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCODEPAGE, codePage, 0);
	return TRUE;
}

int CSciContext::SetUsePalette(CValue** ppParams)
{
	BOOL usePalette=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETUSEPALETTE, usePalette, 0);
	return TRUE;
}

int CSciContext::MarkerDefine(CValue** ppParams)
{
	int markerNumber=ppParams[0]->GetNumeric();
	int markerSymbol=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_MARKERDEFINE, markerNumber, markerSymbol);
	return TRUE;
}

int CSciContext::MarkerSetFore(CValue** ppParams)
{
	int markerNumber=ppParams[0]->GetNumeric();
	COLORREF fore=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_MARKERSETFORE, markerNumber, fore);
	return TRUE;
}

int CSciContext::MarkerSetBack(CValue** ppParams)
{
	int markerNumber=ppParams[0]->GetNumeric();
	COLORREF back=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_MARKERSETBACK, markerNumber, back);
	return TRUE;
}

int CSciContext::MarkerAdd(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	int markerNumber=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_MARKERADD, line, markerNumber);
	return TRUE;
}

int CSciContext::MarkerDelete(CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	int markerNumber=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_MARKERDELETE, line, markerNumber);
	return TRUE;
}

int CSciContext::MarkerDeleteAll(CValue** ppParams)
{
	int markerNumber=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_MARKERDELETEALL, markerNumber, 0);
	return TRUE;
}

int CSciContext::MarkerGet(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_MARKERGET, line, 0);
	return TRUE;
}

int CSciContext::MarkerNext(CValue& retVal, CValue** ppParams)
{
	int lineStart=ppParams[0]->GetNumeric();
	int markerMask=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_MARKERNEXT, lineStart, markerMask);
	return TRUE;
}

int CSciContext::MarkerPrevious(CValue& retVal, CValue** ppParams)
{
	int lineStart=ppParams[0]->GetNumeric();
	int markerMask=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_MARKERPREVIOUS, lineStart, markerMask);
	return TRUE;
}

int CSciContext::MarkerDefinePixmap(CValue** ppParams)
{
	int markerNumber=ppParams[0]->GetNumeric();
	const char* pixmap=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_MARKERDEFINEPIXMAP, markerNumber, reinterpret_cast<LPARAM>(pixmap));
	return TRUE;
}

int CSciContext::MarkerAddSet(CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	int set=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_MARKERADDSET, line, set);
	return TRUE;
}

int CSciContext::MarkerSetAlpha(CValue** ppParams)
{
	int markerNumber=ppParams[0]->GetNumeric();
	int alpha=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_MARKERSETALPHA, markerNumber, alpha);
	return TRUE;
}

int CSciContext::SetMarginTypeN(CValue** ppParams)
{
	int margin=ppParams[0]->GetNumeric();
	int marginType=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETMARGINTYPEN, margin, marginType);
	return TRUE;
}

int CSciContext::GetMarginTypeN(CValue& retVal, CValue** ppParams)
{
	int margin=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETMARGINTYPEN, margin, 0);
	return TRUE;
}

int CSciContext::SetMarginWidthN(CValue** ppParams)
{
	int margin=ppParams[0]->GetNumeric();
	int pixelWidth=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETMARGINWIDTHN, margin, pixelWidth);
	return TRUE;
}

int CSciContext::GetMarginWidthN(CValue& retVal, CValue** ppParams)
{
	int margin=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETMARGINWIDTHN, margin, 0);
	return TRUE;
}

int CSciContext::SetMarginMaskN(CValue** ppParams)
{
	int margin=ppParams[0]->GetNumeric();
	int mask=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETMARGINMASKN, margin, mask);
	return TRUE;
}

int CSciContext::GetMarginMaskN(CValue& retVal, CValue** ppParams)
{
	int margin=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETMARGINMASKN, margin, 0);
	return TRUE;
}

int CSciContext::SetMarginSensitiveN(CValue** ppParams)
{
	int margin=ppParams[0]->GetNumeric();
	BOOL sensitive=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETMARGINSENSITIVEN, margin, sensitive);
	return TRUE;
}

int CSciContext::GetMarginSensitiveN(CValue& retVal, CValue** ppParams)
{
	int margin=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETMARGINSENSITIVEN, margin, 0);
	return TRUE;
}

int CSciContext::StyleClearAll(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_STYLECLEARALL, 0, 0);
	return TRUE;
}

int CSciContext::StyleSetFore(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	COLORREF fore=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETFORE, style, fore);
	return TRUE;
}

int CSciContext::StyleSetBack(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	COLORREF back=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETBACK, style, back);
	return TRUE;
}

int CSciContext::StyleSetBold(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	BOOL bold=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETBOLD, style, bold);
	return TRUE;
}

int CSciContext::StyleSetItalic(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	BOOL italic=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETITALIC, style, italic);
	return TRUE;
}

int CSciContext::StyleSetSize(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	int sizePoints=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETSIZE, style, sizePoints);
	return TRUE;
}

int CSciContext::StyleSetFont(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	const char* fontName=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_STYLESETFONT, style, reinterpret_cast<LPARAM>(fontName));
	return TRUE;
}

int CSciContext::StyleSetEOLFilled(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	BOOL filled=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETEOLFILLED, style, filled);
	return TRUE;
}

int CSciContext::StyleResetDefault(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_STYLERESETDEFAULT, 0, 0);
	return TRUE;
}

int CSciContext::StyleSetUnderline(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	BOOL underline=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETUNDERLINE, style, underline);
	return TRUE;
}

int CSciContext::StyleGetFore(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETFORE, style, 0);
	return TRUE;
}

int CSciContext::StyleGetBack(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETBACK, style, 0);
	return TRUE;
}

int CSciContext::StyleGetBold(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETBOLD, style, 0);
	return TRUE;
}

int CSciContext::StyleGetItalic(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETITALIC, style, 0);
	return TRUE;
}

int CSciContext::StyleGetSize(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETSIZE, style, 0);
	return TRUE;
}

int CSciContext::StyleGetFont(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	const char* fontName=ppParams[1]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETFONT, style, reinterpret_cast<LPARAM>(fontName));
	return TRUE;
}

int CSciContext::StyleGetEOLFilled(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETEOLFILLED, style, 0);
	return TRUE;
}

int CSciContext::StyleGetUnderline(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETUNDERLINE, style, 0);
	return TRUE;
}

int CSciContext::StyleGetCase(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETCASE, style, 0);
	return TRUE;
}

int CSciContext::StyleGetCharacterSet(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETCHARACTERSET, style, 0);
	return TRUE;
}

int CSciContext::StyleGetVisible(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETVISIBLE, style, 0);
	return TRUE;
}

int CSciContext::StyleGetChangeable(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETCHANGEABLE, style, 0);
	return TRUE;
}

int CSciContext::StyleGetHotSpot(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_STYLEGETHOTSPOT, style, 0);
	return TRUE;
}

int CSciContext::StyleSetCase(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	int caseForce=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETCASE, style, caseForce);
	return TRUE;
}

int CSciContext::StyleSetCharacterSet(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	int characterSet=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETCHARACTERSET, style, characterSet);
	return TRUE;
}

int CSciContext::StyleSetHotSpot(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	BOOL hotspot=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETHOTSPOT, style, hotspot);
	return TRUE;
}

int CSciContext::SetSelFore(CValue** ppParams)
{
	BOOL useSetting=ppParams[0]->GetNumeric();
	COLORREF fore=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSELFORE, useSetting, fore);
	return TRUE;
}

int CSciContext::SetSelBack(CValue** ppParams)
{
	BOOL useSetting=ppParams[0]->GetNumeric();
	COLORREF back=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSELBACK, useSetting, back);
	return TRUE;
}

int CSciContext::GetSelAlpha(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSELALPHA, 0, 0);
	return TRUE;
}

int CSciContext::SetSelAlpha(CValue** ppParams)
{
	int alpha=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSELALPHA, alpha, 0);
	return TRUE;
}

int CSciContext::GetSelEOLFilled(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSELEOLFILLED, 0, 0);
	return TRUE;
}

int CSciContext::SetSelEOLFilled(CValue** ppParams)
{
	BOOL filled=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSELEOLFILLED, filled, 0);
	return TRUE;
}

int CSciContext::SetCaretFore(CValue** ppParams)
{
	COLORREF fore=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCARETFORE, fore, 0);
	return TRUE;
}

int CSciContext::AssignCmdKey(CValue** ppParams)
{
	DWORD km=ppParams[0]->GetNumeric();
	int msg=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_ASSIGNCMDKEY, km, msg);
	return TRUE;
}

int CSciContext::ClearCmdKey(CValue** ppParams)
{
	DWORD km=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_CLEARCMDKEY, km, 0);
	return TRUE;
}

int CSciContext::ClearAllCmdKeys(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CLEARALLCMDKEYS, 0, 0);
	return TRUE;
}

int CSciContext::SetStylingEx(CValue** ppParams)
{
	int length=ppParams[0]->GetNumeric();
	const char* styles=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_SETSTYLINGEX, length, reinterpret_cast<LPARAM>(styles));
	return TRUE;
}

int CSciContext::StyleSetVisible(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	BOOL visible=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETVISIBLE, style, visible);
	return TRUE;
}

int CSciContext::GetCaretPeriod(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCARETPERIOD, 0, 0);
	return TRUE;
}

int CSciContext::SetCaretPeriod(CValue** ppParams)
{
	int periodMilliseconds=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCARETPERIOD, periodMilliseconds, 0);
	return TRUE;
}

int CSciContext::SetWordChars(CValue** ppParams)
{
	const char* characters=ppParams[0]->GetString();
	m_pSciCtrl->Call(SCI_SETWORDCHARS, 0, reinterpret_cast<LPARAM>(characters));
	return TRUE;
}

int CSciContext::BeginUndoAction(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_BEGINUNDOACTION, 0, 0);
	return TRUE;
}

int CSciContext::EndUndoAction(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_ENDUNDOACTION, 0, 0);
	return TRUE;
}

int CSciContext::IndicSetStyle(CValue** ppParams)
{
	int indic=ppParams[0]->GetNumeric();
	int style=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_INDICSETSTYLE, indic, style);
	return TRUE;
}

int CSciContext::IndicGetStyle(CValue& retVal, CValue** ppParams)
{
	int indic=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_INDICGETSTYLE, indic, 0);
	return TRUE;
}

int CSciContext::IndicSetFore(CValue** ppParams)
{
	int indic=ppParams[0]->GetNumeric();
	COLORREF fore=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_INDICSETFORE, indic, fore);
	return TRUE;
}

int CSciContext::IndicGetFore(CValue& retVal, CValue** ppParams)
{
	int indic=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_INDICGETFORE, indic, 0);
	return TRUE;
}

int CSciContext::IndicSetUnder(CValue** ppParams)
{
	int indic=ppParams[0]->GetNumeric();
	BOOL under=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_INDICSETUNDER, indic, under);
	return TRUE;
}

int CSciContext::IndicGetUnder(CValue& retVal, CValue** ppParams)
{
	int indic=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_INDICGETUNDER, indic, 0);
	return TRUE;
}

int CSciContext::SetWhitespaceFore(CValue** ppParams)
{
	BOOL useSetting=ppParams[0]->GetNumeric();
	COLORREF fore=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETWHITESPACEFORE, useSetting, fore);
	return TRUE;
}

int CSciContext::SetWhitespaceBack(CValue** ppParams)
{
	BOOL useSetting=ppParams[0]->GetNumeric();
	COLORREF back=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETWHITESPACEBACK, useSetting, back);
	return TRUE;
}

int CSciContext::SetStyleBits(CValue** ppParams)
{
	int bits=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSTYLEBITS, bits, 0);
	return TRUE;
}

int CSciContext::GetStyleBits(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSTYLEBITS, 0, 0);
	return TRUE;
}

int CSciContext::SetLineState(CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	int state=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETLINESTATE, line, state);
	return TRUE;
}

int CSciContext::GetLineState(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLINESTATE, line, 0);
	return TRUE;
}

int CSciContext::GetMaxLineState(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETMAXLINESTATE, 0, 0);
	return TRUE;
}

int CSciContext::GetCaretLineVisible(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCARETLINEVISIBLE, 0, 0);
	return TRUE;
}

int CSciContext::SetCaretLineVisible(CValue** ppParams)
{
	BOOL show=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCARETLINEVISIBLE, show, 0);
	return TRUE;
}

int CSciContext::GetCaretLineBack(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCARETLINEBACK, 0, 0);
	return TRUE;
}

int CSciContext::SetCaretLineBack(CValue** ppParams)
{
	COLORREF back=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCARETLINEBACK, back, 0);
	return TRUE;
}

int CSciContext::StyleSetChangeable(CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	BOOL changeable=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_STYLESETCHANGEABLE, style, changeable);
	return TRUE;
}

int CSciContext::AutoCShow(CValue** ppParams)
{
	int lenEntered=ppParams[0]->GetNumeric();
	const char* itemList=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_AUTOCSHOW, lenEntered, reinterpret_cast<LPARAM>(itemList));
	return TRUE;
}

int CSciContext::AutoCCancel(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_AUTOCCANCEL, 0, 0);
	return TRUE;
}

int CSciContext::AutoCActive(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCACTIVE, 0, 0);
	return TRUE;
}

int CSciContext::AutoCPosStart(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCPOSSTART, 0, 0);
	return TRUE;
}

int CSciContext::AutoCComplete(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_AUTOCCOMPLETE, 0, 0);
	return TRUE;
}

int CSciContext::AutoCStops(CValue** ppParams)
{
	const char* characterSet=ppParams[0]->GetString();
	m_pSciCtrl->Call(SCI_AUTOCSTOPS, 0, reinterpret_cast<LPARAM>(characterSet));
	return TRUE;
}

int CSciContext::AutoCSetSeparator(CValue** ppParams)
{
	int separatorCharacter=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_AUTOCSETSEPARATOR, separatorCharacter, 0);
	return TRUE;
}

int CSciContext::AutoCGetSeparator(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCGETSEPARATOR, 0, 0);
	return TRUE;
}

int CSciContext::AutoCSelect(CValue** ppParams)
{
	const char* text=ppParams[0]->GetString();
	m_pSciCtrl->Call(SCI_AUTOCSELECT, 0, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::AutoCSetCancelAtStart(CValue** ppParams)
{
	BOOL cancel=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_AUTOCSETCANCELATSTART, cancel, 0);
	return TRUE;
}

int CSciContext::AutoCGetCancelAtStart(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCGETCANCELATSTART, 0, 0);
	return TRUE;
}

int CSciContext::AutoCSetFillUps(CValue** ppParams)
{
	const char* characterSet=ppParams[0]->GetString();
	m_pSciCtrl->Call(SCI_AUTOCSETFILLUPS, 0, reinterpret_cast<LPARAM>(characterSet));
	return TRUE;
}

int CSciContext::AutoCSetChooseSingle(CValue** ppParams)
{
	BOOL chooseSingle=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_AUTOCSETCHOOSESINGLE, chooseSingle, 0);
	return TRUE;
}

int CSciContext::AutoCGetChooseSingle(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCGETCHOOSESINGLE, 0, 0);
	return TRUE;
}

int CSciContext::AutoCSetIgnoreCase(CValue** ppParams)
{
	BOOL ignoreCase=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_AUTOCSETIGNORECASE, ignoreCase, 0);
	return TRUE;
}

int CSciContext::AutoCGetIgnoreCase(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCGETIGNORECASE, 0, 0);
	return TRUE;
}

int CSciContext::UserListShow(CValue** ppParams)
{
	int listType=ppParams[0]->GetNumeric();
	const char* itemList=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_USERLISTSHOW, listType, reinterpret_cast<LPARAM>(itemList));
	return TRUE;
}

int CSciContext::AutoCSetAutoHide(CValue** ppParams)
{
	BOOL autoHide=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_AUTOCSETAUTOHIDE, autoHide, 0);
	return TRUE;
}

int CSciContext::AutoCGetAutoHide(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCGETAUTOHIDE, 0, 0);
	return TRUE;
}

int CSciContext::AutoCSetDropRestOfWord(CValue** ppParams)
{
	BOOL dropRestOfWord=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_AUTOCSETDROPRESTOFWORD, dropRestOfWord, 0);
	return TRUE;
}

int CSciContext::AutoCGetDropRestOfWord(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCGETDROPRESTOFWORD, 0, 0);
	return TRUE;
}

int CSciContext::RegisterImage(CValue** ppParams)
{
	int type=ppParams[0]->GetNumeric();
	const char* xpmData=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_REGISTERIMAGE, type, reinterpret_cast<LPARAM>(xpmData));
	return TRUE;
}

int CSciContext::ClearRegisteredImages(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CLEARREGISTEREDIMAGES, 0, 0);
	return TRUE;
}

int CSciContext::AutoCGetTypeSeparator(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCGETTYPESEPARATOR, 0, 0);
	return TRUE;
}

int CSciContext::AutoCSetTypeSeparator(CValue** ppParams)
{
	int separatorCharacter=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_AUTOCSETTYPESEPARATOR, separatorCharacter, 0);
	return TRUE;
}

int CSciContext::AutoCSetMaxWidth(CValue** ppParams)
{
	int characterCount=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_AUTOCSETMAXWIDTH, characterCount, 0);
	return TRUE;
}

int CSciContext::AutoCGetMaxWidth(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCGETMAXWIDTH, 0, 0);
	return TRUE;
}

int CSciContext::AutoCSetMaxHeight(CValue** ppParams)
{
	int rowCount=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_AUTOCSETMAXHEIGHT, rowCount, 0);
	return TRUE;
}

int CSciContext::AutoCGetMaxHeight(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCGETMAXHEIGHT, 0, 0);
	return TRUE;
}

int CSciContext::SetIndent(CValue** ppParams)
{
	int indentSize=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETINDENT, indentSize, 0);
	return TRUE;
}

int CSciContext::GetIndent(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETINDENT, 0, 0);
	return TRUE;
}

int CSciContext::SetUseTabs(CValue** ppParams)
{
	BOOL useTabs=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETUSETABS, useTabs, 0);
	return TRUE;
}

int CSciContext::GetUseTabs(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETUSETABS, 0, 0);
	return TRUE;
}

int CSciContext::SetLineIndentation(CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	int indentSize=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETLINEINDENTATION, line, indentSize);
	return TRUE;
}

int CSciContext::GetLineIndentation(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLINEINDENTATION, line, 0);
	return TRUE;
}

int CSciContext::GetLineIndentPosition(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLINEINDENTPOSITION, line, 0);
	return TRUE;
}

int CSciContext::GetColumn(CValue& retVal, CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCOLUMN, pos, 0);
	return TRUE;
}

int CSciContext::SetHScrollBar(CValue** ppParams)
{
	BOOL show=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETHSCROLLBAR, show, 0);
	return TRUE;
}

int CSciContext::GetHScrollBar(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETHSCROLLBAR, 0, 0);
	return TRUE;
}

int CSciContext::SetIndentationGuides(CValue** ppParams)
{
	int indentView=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETINDENTATIONGUIDES, indentView, 0);
	return TRUE;
}

int CSciContext::GetIndentationGuides(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETINDENTATIONGUIDES, 0, 0);
	return TRUE;
}

int CSciContext::SetHighlightGuide(CValue** ppParams)
{
	int column=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETHIGHLIGHTGUIDE, column, 0);
	return TRUE;
}

int CSciContext::GetHighlightGuide(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETHIGHLIGHTGUIDE, 0, 0);
	return TRUE;
}

int CSciContext::GetLineEndPosition(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLINEENDPOSITION, line, 0);
	return TRUE;
}

int CSciContext::GetCodePage(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCODEPAGE, 0, 0);
	return TRUE;
}

int CSciContext::GetCaretFore(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCARETFORE, 0, 0);
	return TRUE;
}

int CSciContext::GetUsePalette(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETUSEPALETTE, 0, 0);
	return TRUE;
}

int CSciContext::GetReadOnly(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETREADONLY, 0, 0);
	return TRUE;
}

int CSciContext::SetCurrentPos(CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCURRENTPOS, pos, 0);
	return TRUE;
}

int CSciContext::SetSelectionStart(CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSELECTIONSTART, pos, 0);
	return TRUE;
}

int CSciContext::GetSelectionStart(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSELECTIONSTART, 0, 0);
	return TRUE;
}

int CSciContext::SetSelectionEnd(CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSELECTIONEND, pos, 0);
	return TRUE;
}

int CSciContext::GetSelectionEnd(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSELECTIONEND, 0, 0);
	return TRUE;
}

int CSciContext::SetPrintMagnification(CValue** ppParams)
{
	int magnification=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETPRINTMAGNIFICATION, magnification, 0);
	return TRUE;
}

int CSciContext::GetPrintMagnification(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETPRINTMAGNIFICATION, 0, 0);
	return TRUE;
}

int CSciContext::SetPrintColourMode(CValue** ppParams)
{
	int mode=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETPRINTCOLOURMODE, mode, 0);
	return TRUE;
}

int CSciContext::GetPrintColourMode(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETPRINTCOLOURMODE, 0, 0);
	return TRUE;
}

int CSciContext::FindText(CValue& retVal, CValue** ppParams)
{
	int flags=ppParams[0]->GetNumeric();
	const char* ft=ppParams[1]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_FINDTEXT, flags, reinterpret_cast<LPARAM>(ft));
	return TRUE;
}

int CSciContext::FormatRange(CValue& retVal, CValue** ppParams)
{
	BOOL draw=ppParams[0]->GetNumeric();
	const char* fr=ppParams[1]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_FORMATRANGE, draw, reinterpret_cast<LPARAM>(fr));
	return TRUE;
}

int CSciContext::GetFirstVisibleLine(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETFIRSTVISIBLELINE, 0, 0);
	return TRUE;
}


int CSciContext::GetLineCount(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLINECOUNT, 0, 0);
	return TRUE;
}

int CSciContext::SetMarginLeft(CValue** ppParams)
{
	int pixelWidth=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETMARGINLEFT, 0, pixelWidth);
	return TRUE;
}

int CSciContext::GetMarginLeft(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETMARGINLEFT, 0, 0);
	return TRUE;
}

int CSciContext::SetMarginRight(CValue** ppParams)
{
	int pixelWidth=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETMARGINRIGHT, 0, pixelWidth);
	return TRUE;
}

int CSciContext::GetMarginRight(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETMARGINRIGHT, 0, 0);
	return TRUE;
}

int CSciContext::GetModify(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETMODIFY, 0, 0);
	return TRUE;
}

int CSciContext::SetSel(CValue** ppParams)
{
	long start=ppParams[0]->GetNumeric();
	long end=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSEL, start, end);
	return TRUE;
}



int CSciContext::HideSelection(CValue** ppParams)
{
	BOOL normal=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_HIDESELECTION, normal, 0);
	return TRUE;
}

int CSciContext::PointXFromPosition(CValue& retVal, CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_POINTXFROMPOSITION, 0, pos);
	return TRUE;
}

int CSciContext::PointYFromPosition(CValue& retVal, CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_POINTYFROMPOSITION, 0, pos);
	return TRUE;
}

int CSciContext::LineFromPosition(CValue& retVal, CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_LINEFROMPOSITION, pos, 0);
	return TRUE;
}

int CSciContext::PositionFromLine(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_POSITIONFROMLINE, line, 0);
	return TRUE;
}

int CSciContext::LineScroll(CValue** ppParams)
{
	int columns=ppParams[0]->GetNumeric();
	int lines=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_LINESCROLL, columns, lines);
	return TRUE;
}

int CSciContext::ScrollCaret(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_SCROLLCARET, 0, 0);
	return TRUE;
}

int CSciContext::ReplaceSel(CValue** ppParams)
{
	const char* text=ppParams[0]->GetString();
	m_pSciCtrl->Call(SCI_REPLACESEL, 0, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::SetReadOnly(CValue** ppParams)
{
	BOOL readOnly=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETREADONLY, readOnly, 0);
	return TRUE;
}

int CSciContext::Null(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_NULL, 0, 0);
	return TRUE;
}

int CSciContext::CanPaste(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_CANPASTE, 0, 0);
	return TRUE;
}

int CSciContext::CanUndo(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_CANUNDO, 0, 0);
	return TRUE;
}

int CSciContext::EmptyUndoBuffer(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_EMPTYUNDOBUFFER, 0, 0);
	return TRUE;
}

int CSciContext::Undo(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_UNDO, 0, 0);
	return TRUE;
}

int CSciContext::Cut(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CUT, 0, 0);
	return TRUE;
}

int CSciContext::Copy(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_COPY, 0, 0);
	return TRUE;
}

int CSciContext::Paste(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_PASTE, 0, 0);
	return TRUE;
}

int CSciContext::Clear(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CLEAR, 0, 0);
	return TRUE;
}

int CSciContext::SetText(CValue** ppParams)
{
	const char* text=ppParams[0]->GetString();
	m_pSciCtrl->Call(SCI_SETTEXT, 0, reinterpret_cast<LPARAM>(text));
	return TRUE;
}


int CSciContext::GetTextLength(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETTEXTLENGTH, 0, 0);
	return TRUE;
}

int CSciContext::SetOvertype(CValue** ppParams)
{
	BOOL overtype=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETOVERTYPE, overtype, 0);
	return TRUE;
}

int CSciContext::GetOvertype(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETOVERTYPE, 0, 0);
	return TRUE;
}

int CSciContext::SetCaretWidth(CValue** ppParams)
{
	int pixelWidth=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCARETWIDTH, pixelWidth, 0);
	return TRUE;
}

int CSciContext::GetCaretWidth(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCARETWIDTH, 0, 0);
	return TRUE;
}

int CSciContext::SetTargetStart(CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETTARGETSTART, pos, 0);
	return TRUE;
}

int CSciContext::GetTargetStart(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETTARGETSTART, 0, 0);
	return TRUE;
}

int CSciContext::SetTargetEnd(CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETTARGETEND, pos, 0);
	return TRUE;
}

int CSciContext::GetTargetEnd(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETTARGETEND, 0, 0);
	return TRUE;
}

int CSciContext::ReplaceTarget(CValue& retVal, CValue** ppParams)
{
	int length=ppParams[0]->GetNumeric();
	const char* text=ppParams[1]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_REPLACETARGET, length, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::ReplaceTargetRE(CValue& retVal, CValue** ppParams)
{
	int length=ppParams[0]->GetNumeric();
	const char* text=ppParams[1]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_REPLACETARGETRE, length, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::SearchInTarget(CValue& retVal, CValue** ppParams)
{
	int length=ppParams[0]->GetNumeric();
	const char* text=ppParams[1]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_SEARCHINTARGET, length, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::SetSearchFlags(CValue** ppParams)
{
	int flags=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSEARCHFLAGS, flags, 0);
	return TRUE;
}

int CSciContext::GetSearchFlags(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSEARCHFLAGS, 0, 0);
	return TRUE;
}

int CSciContext::CallTipShow(CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	const char* definition=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_CALLTIPSHOW, pos, reinterpret_cast<LPARAM>(definition));
	return TRUE;
}

int CSciContext::CallTipCancel(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CALLTIPCANCEL, 0, 0);
	return TRUE;
}

int CSciContext::CallTipActive(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_CALLTIPACTIVE, 0, 0);
	return TRUE;
}

int CSciContext::CallTipPosStart(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_CALLTIPPOSSTART, 0, 0);
	return TRUE;
}

int CSciContext::CallTipSetHlt(CValue** ppParams)
{
	int start=ppParams[0]->GetNumeric();
	int end=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_CALLTIPSETHLT, start, end);
	return TRUE;
}

int CSciContext::CallTipSetBack(CValue** ppParams)
{
	COLORREF back=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_CALLTIPSETBACK, back, 0);
	return TRUE;
}

int CSciContext::CallTipSetFore(CValue** ppParams)
{
	COLORREF fore=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_CALLTIPSETFORE, fore, 0);
	return TRUE;
}

int CSciContext::CallTipSetForeHlt(CValue** ppParams)
{
	COLORREF fore=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_CALLTIPSETFOREHLT, fore, 0);
	return TRUE;
}

int CSciContext::CallTipUseStyle(CValue** ppParams)
{
	int tabSize=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_CALLTIPUSESTYLE, tabSize, 0);
	return TRUE;
}

int CSciContext::VisibleFromDocLine(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_VISIBLEFROMDOCLINE, line, 0);
	return TRUE;
}

int CSciContext::DocLineFromVisible(CValue& retVal, CValue** ppParams)
{
	int lineDisplay=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_DOCLINEFROMVISIBLE, lineDisplay, 0);
	return TRUE;
}

int CSciContext::WrapCount(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_WRAPCOUNT, line, 0);
	return TRUE;
}

int CSciContext::SetFoldLevel(CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	int level=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETFOLDLEVEL, line, level);
	return TRUE;
}

int CSciContext::GetFoldLevel(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETFOLDLEVEL, line, 0);
	return TRUE;
}

int CSciContext::GetLastChild(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	int level=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLASTCHILD, line, level);
	return TRUE;
}

int CSciContext::GetFoldParent(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETFOLDPARENT, line, 0);
	return TRUE;
}

int CSciContext::ShowLines(CValue** ppParams)
{
	int lineStart=ppParams[0]->GetNumeric();
	int lineEnd=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SHOWLINES, lineStart, lineEnd);
	return TRUE;
}

int CSciContext::HideLines(CValue** ppParams)
{
	int lineStart=ppParams[0]->GetNumeric();
	int lineEnd=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_HIDELINES, lineStart, lineEnd);
	return TRUE;
}

int CSciContext::GetLineVisible(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLINEVISIBLE, line, 0);
	return TRUE;
}

int CSciContext::SetFoldExpanded(CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	BOOL expanded=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETFOLDEXPANDED, line, expanded);
	return TRUE;
}

int CSciContext::GetFoldExpanded(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETFOLDEXPANDED, line, 0);
	return TRUE;
}

int CSciContext::ToggleFold(CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_TOGGLEFOLD, line, 0);
	return TRUE;
}

int CSciContext::EnsureVisible(CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_ENSUREVISIBLE, line, 0);
	return TRUE;
}

int CSciContext::SetFoldFlags(CValue** ppParams)
{
	int flags=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETFOLDFLAGS, flags, 0);
	return TRUE;
}

int CSciContext::EnsureVisibleEnforcePolicy(CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_ENSUREVISIBLEENFORCEPOLICY, line, 0);
	return TRUE;
}

int CSciContext::SetTabIndents(CValue** ppParams)
{
	BOOL tabIndents=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETTABINDENTS, tabIndents, 0);
	return TRUE;
}

int CSciContext::GetTabIndents(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETTABINDENTS, 0, 0);
	return TRUE;
}

int CSciContext::SetBackSpaceUnIndents(CValue** ppParams)
{
	BOOL bsUnIndents=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETBACKSPACEUNINDENTS, bsUnIndents, 0);
	return TRUE;
}

int CSciContext::GetBackSpaceUnIndents(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETBACKSPACEUNINDENTS, 0, 0);
	return TRUE;
}

int CSciContext::SetMouseDwellTime(CValue** ppParams)
{
	int periodMilliseconds=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETMOUSEDWELLTIME, periodMilliseconds, 0);
	return TRUE;
}

int CSciContext::GetMouseDwellTime(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETMOUSEDWELLTIME, 0, 0);
	return TRUE;
}

int CSciContext::WordStartPosition(CValue& retVal, CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	BOOL onlyWordCharacters=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_WORDSTARTPOSITION, pos, onlyWordCharacters);
	return TRUE;
}

int CSciContext::WordEndPosition(CValue& retVal, CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	BOOL onlyWordCharacters=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_WORDENDPOSITION, pos, onlyWordCharacters);
	return TRUE;
}

int CSciContext::SetWrapMode(CValue** ppParams)
{
	int mode=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETWRAPMODE, mode, 0);
	return TRUE;
}

int CSciContext::GetWrapMode(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETWRAPMODE, 0, 0);
	return TRUE;
}

int CSciContext::SetWrapVisualFlags(CValue** ppParams)
{
	int wrapVisualFlags=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETWRAPVISUALFLAGS, wrapVisualFlags, 0);
	return TRUE;
}

int CSciContext::GetWrapVisualFlags(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETWRAPVISUALFLAGS, 0, 0);
	return TRUE;
}

int CSciContext::SetWrapVisualFlagsLocation(CValue** ppParams)
{
	int wrapVisualFlagsLocation=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETWRAPVISUALFLAGSLOCATION, wrapVisualFlagsLocation, 0);
	return TRUE;
}

int CSciContext::GetWrapVisualFlagsLocation(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETWRAPVISUALFLAGSLOCATION, 0, 0);
	return TRUE;
}

int CSciContext::SetWrapStartIndent(CValue** ppParams)
{
	int indent=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETWRAPSTARTINDENT, indent, 0);
	return TRUE;
}

int CSciContext::GetWrapStartIndent(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETWRAPSTARTINDENT, 0, 0);
	return TRUE;
}

int CSciContext::SetLayoutCache(CValue** ppParams)
{
	int mode=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETLAYOUTCACHE, mode, 0);
	return TRUE;
}

int CSciContext::GetLayoutCache(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLAYOUTCACHE, 0, 0);
	return TRUE;
}

int CSciContext::SetScrollWidth(CValue** ppParams)
{
	int pixelWidth=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSCROLLWIDTH, pixelWidth, 0);
	return TRUE;
}

int CSciContext::GetScrollWidth(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSCROLLWIDTH, 0, 0);
	return TRUE;
}

int CSciContext::SetScrollWidthTracking(CValue** ppParams)
{
	BOOL tracking=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSCROLLWIDTHTRACKING, tracking, 0);
	return TRUE;
}

int CSciContext::GetScrollWidthTracking(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSCROLLWIDTHTRACKING, 0, 0);
	return TRUE;
}

int CSciContext::TextWidth(CValue& retVal, CValue** ppParams)
{
	int style=ppParams[0]->GetNumeric();
	const char* text=ppParams[1]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_TEXTWIDTH, style, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::SetEndAtLastLine(CValue** ppParams)
{
	BOOL endAtLastLine=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETENDATLASTLINE, endAtLastLine, 0);
	return TRUE;
}

int CSciContext::GetEndAtLastLine(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETENDATLASTLINE, 0, 0);
	return TRUE;
}

int CSciContext::TextHeight(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_TEXTHEIGHT, line, 0);
	return TRUE;
}

int CSciContext::SetVScrollBar(CValue** ppParams)
{
	BOOL show=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETVSCROLLBAR, show, 0);
	return TRUE;
}

int CSciContext::GetVScrollBar(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETVSCROLLBAR, 0, 0);
	return TRUE;
}

int CSciContext::AppendText(CValue** ppParams)
{
	int length=ppParams[0]->GetNumeric();
	const char* text=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_APPENDTEXT, length, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::GetTwoPhaseDraw(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETTWOPHASEDRAW, 0, 0);
	return TRUE;
}

int CSciContext::SetTwoPhaseDraw(CValue** ppParams)
{
	BOOL twoPhase=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETTWOPHASEDRAW, twoPhase, 0);
	return TRUE;
}

int CSciContext::TargetFromSelection(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_TARGETFROMSELECTION, 0, 0);
	return TRUE;
}

int CSciContext::LinesJoin(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINESJOIN, 0, 0);
	return TRUE;
}

int CSciContext::LinesSplit(CValue** ppParams)
{
	int pixelWidth=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_LINESSPLIT, pixelWidth, 0);
	return TRUE;
}

int CSciContext::SetFoldMarginColour(CValue** ppParams)
{
	BOOL useSetting=ppParams[0]->GetNumeric();
	COLORREF back=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETFOLDMARGINCOLOUR, useSetting, back);
	return TRUE;
}

int CSciContext::SetFoldMarginHiColour(CValue** ppParams)
{
	BOOL useSetting=ppParams[0]->GetNumeric();
	COLORREF fore=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETFOLDMARGINHICOLOUR, useSetting, fore);
	return TRUE;
}

int CSciContext::LineDown(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEDOWN, 0, 0);
	return TRUE;
}

int CSciContext::LineDownExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEDOWNEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::LineUp(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEUP, 0, 0);
	return TRUE;
}

int CSciContext::LineUpExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEUPEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::CharLeft(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CHARLEFT, 0, 0);
	return TRUE;
}

int CSciContext::CharLeftExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CHARLEFTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::CharRight(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CHARRIGHT, 0, 0);
	return TRUE;
}

int CSciContext::CharRightExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CHARRIGHTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::WordLeft(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDLEFT, 0, 0);
	return TRUE;
}

int CSciContext::WordLeftExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDLEFTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::WordRight(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDRIGHT, 0, 0);
	return TRUE;
}

int CSciContext::WordRightExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDRIGHTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::Home(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_HOME, 0, 0);
	return TRUE;
}

int CSciContext::HomeExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_HOMEEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::LineEnd(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEEND, 0, 0);
	return TRUE;
}

int CSciContext::LineEndExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEENDEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::DocumentStart(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_DOCUMENTSTART, 0, 0);
	return TRUE;
}

int CSciContext::DocumentStartExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_DOCUMENTSTARTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::DocumentEnd(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_DOCUMENTEND, 0, 0);
	return TRUE;
}

int CSciContext::DocumentEndExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_DOCUMENTENDEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::PageUp(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_PAGEUP, 0, 0);
	return TRUE;
}

int CSciContext::PageUpExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_PAGEUPEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::PageDown(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_PAGEDOWN, 0, 0);
	return TRUE;
}

int CSciContext::PageDownExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_PAGEDOWNEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::EditToggleOvertype(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_EDITTOGGLEOVERTYPE, 0, 0);
	return TRUE;
}

int CSciContext::Cancel(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CANCEL, 0, 0);
	return TRUE;
}

int CSciContext::DeleteBack(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_DELETEBACK, 0, 0);
	return TRUE;
}

int CSciContext::Tab(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_TAB, 0, 0);
	return TRUE;
}

int CSciContext::BackTab(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_BACKTAB, 0, 0);
	return TRUE;
}

int CSciContext::NewLine(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_NEWLINE, 0, 0);
	return TRUE;
}

int CSciContext::FormFeed(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_FORMFEED, 0, 0);
	return TRUE;
}

int CSciContext::VCHome(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_VCHOME, 0, 0);
	return TRUE;
}

int CSciContext::VCHomeExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_VCHOMEEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::ZoomIn(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_ZOOMIN, 0, 0);
	return TRUE;
}

int CSciContext::ZoomOut(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_ZOOMOUT, 0, 0);
	return TRUE;
}

int CSciContext::DelWordLeft(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_DELWORDLEFT, 0, 0);
	return TRUE;
}

int CSciContext::DelWordRight(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_DELWORDRIGHT, 0, 0);
	return TRUE;
}

int CSciContext::DelWordRightEnd(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_DELWORDRIGHTEND, 0, 0);
	return TRUE;
}

int CSciContext::LineCut(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINECUT, 0, 0);
	return TRUE;
}

int CSciContext::LineDelete(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEDELETE, 0, 0);
	return TRUE;
}

int CSciContext::LineTranspose(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINETRANSPOSE, 0, 0);
	return TRUE;
}

int CSciContext::LineDuplicate(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEDUPLICATE, 0, 0);
	return TRUE;
}

int CSciContext::LowerCase(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LOWERCASE, 0, 0);
	return TRUE;
}

int CSciContext::UpperCase(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_UPPERCASE, 0, 0);
	return TRUE;
}

int CSciContext::LineScrollDown(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINESCROLLDOWN, 0, 0);
	return TRUE;
}

int CSciContext::LineScrollUp(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINESCROLLUP, 0, 0);
	return TRUE;
}

int CSciContext::DeleteBackNotLine(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_DELETEBACKNOTLINE, 0, 0);
	return TRUE;
}

int CSciContext::HomeDisplay(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_HOMEDISPLAY, 0, 0);
	return TRUE;
}

int CSciContext::HomeDisplayExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_HOMEDISPLAYEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::LineEndDisplay(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEENDDISPLAY, 0, 0);
	return TRUE;
}

int CSciContext::LineEndDisplayExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEENDDISPLAYEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::HomeWrap(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_HOMEWRAP, 0, 0);
	return TRUE;
}

int CSciContext::HomeWrapExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_HOMEWRAPEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::LineEndWrap(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEENDWRAP, 0, 0);
	return TRUE;
}

int CSciContext::LineEndWrapExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEENDWRAPEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::VCHomeWrap(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_VCHOMEWRAP, 0, 0);
	return TRUE;
}

int CSciContext::VCHomeWrapExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_VCHOMEWRAPEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::LineCopy(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINECOPY, 0, 0);
	return TRUE;
}

int CSciContext::MoveCaretInsideView(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_MOVECARETINSIDEVIEW, 0, 0);
	return TRUE;
}

int CSciContext::LineLength(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_LINELENGTH, line, 0);
	return TRUE;
}

int CSciContext::BraceHighlight(CValue** ppParams)
{
	long pos1=ppParams[0]->GetNumeric();
	long pos2=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_BRACEHIGHLIGHT, pos1, pos2);
	return TRUE;
}

int CSciContext::BraceBadLight(CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_BRACEBADLIGHT, pos, 0);
	return TRUE;
}

int CSciContext::BraceMatch(CValue& retVal, CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_BRACEMATCH, pos, 0);
	return TRUE;
}

int CSciContext::GetViewEOL(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETVIEWEOL, 0, 0);
	return TRUE;
}

int CSciContext::SetViewEOL(CValue** ppParams)
{
	BOOL visible=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETVIEWEOL, visible, 0);
	return TRUE;
}

int CSciContext::GetDocPointer(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETDOCPOINTER, 0, 0);
	return TRUE;
}

int CSciContext::SetDocPointer(CValue** ppParams)
{
	int pointer=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETDOCPOINTER, 0, pointer);
	return TRUE;
}

int CSciContext::SetModEventMask(CValue** ppParams)
{
	int mask=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETMODEVENTMASK, mask, 0);
	return TRUE;
}

int CSciContext::GetEdgeColumn(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETEDGECOLUMN, 0, 0);
	return TRUE;
}

int CSciContext::SetEdgeColumn(CValue** ppParams)
{
	int column=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETEDGECOLUMN, column, 0);
	return TRUE;
}

int CSciContext::GetEdgeMode(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETEDGEMODE, 0, 0);
	return TRUE;
}

int CSciContext::SetEdgeMode(CValue** ppParams)
{
	int mode=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETEDGEMODE, mode, 0);
	return TRUE;
}

int CSciContext::GetEdgeColour(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETEDGECOLOUR, 0, 0);
	return TRUE;
}

int CSciContext::SetEdgeColour(CValue** ppParams)
{
	COLORREF edgeColour=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETEDGECOLOUR, edgeColour, 0);
	return TRUE;
}

int CSciContext::SearchAnchor(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_SEARCHANCHOR, 0, 0);
	return TRUE;
}

int CSciContext::SearchNext(CValue& retVal, CValue** ppParams)
{
	int flags=ppParams[0]->GetNumeric();
	const char* text=ppParams[1]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_SEARCHNEXT, flags, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::SearchPrev(CValue& retVal, CValue** ppParams)
{
	int flags=ppParams[0]->GetNumeric();
	const char* text=ppParams[1]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_SEARCHPREV, flags, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::LinesOnScreen(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_LINESONSCREEN, 0, 0);
	return TRUE;
}

int CSciContext::UsePopUp(CValue** ppParams)
{
	BOOL allowPopUp=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_USEPOPUP, allowPopUp, 0);
	return TRUE;
}

int CSciContext::SelectionIsRectangle(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_SELECTIONISRECTANGLE, 0, 0);
	return TRUE;
}

int CSciContext::SetZoom(CValue** ppParams)
{
	int zoom=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETZOOM, zoom, 0);
	return TRUE;
}

int CSciContext::GetZoom(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETZOOM, 0, 0);
	return TRUE;
}

int CSciContext::CreateDocument(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_CREATEDOCUMENT, 0, 0);
	return TRUE;
}

int CSciContext::AddRefDocument(CValue** ppParams)
{
	int doc=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_ADDREFDOCUMENT, 0, doc);
	return TRUE;
}

int CSciContext::ReleaseDocument(CValue** ppParams)
{
	int doc=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_RELEASEDOCUMENT, 0, doc);
	return TRUE;
}

int CSciContext::GetModEventMask(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETMODEVENTMASK, 0, 0);
	return TRUE;
}

int CSciContext::SetFocus(CValue** ppParams)
{
	BOOL focus=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETFOCUS, focus, 0);
	return TRUE;
}

int CSciContext::GetFocus(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETFOCUS, 0, 0);
	return TRUE;
}

int CSciContext::SetStatus(CValue** ppParams)
{
	int statusCode=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSTATUS, statusCode, 0);
	return TRUE;
}

int CSciContext::GetStatus(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSTATUS, 0, 0);
	return TRUE;
}

int CSciContext::SetMouseDownCaptures(CValue** ppParams)
{
	BOOL captures=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETMOUSEDOWNCAPTURES, captures, 0);
	return TRUE;
}

int CSciContext::GetMouseDownCaptures(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETMOUSEDOWNCAPTURES, 0, 0);
	return TRUE;
}

int CSciContext::SetCursor(CValue** ppParams)
{
	int cursorType=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCURSOR, cursorType, 0);
	return TRUE;
}

int CSciContext::GetCursor(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCURSOR, 0, 0);
	return TRUE;
}

int CSciContext::SetControlCharSymbol(CValue** ppParams)
{
	int symbol=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCONTROLCHARSYMBOL, symbol, 0);
	return TRUE;
}

int CSciContext::GetControlCharSymbol(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCONTROLCHARSYMBOL, 0, 0);
	return TRUE;
}

int CSciContext::WordPartLeft(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDPARTLEFT, 0, 0);
	return TRUE;
}

int CSciContext::WordPartLeftExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDPARTLEFTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::WordPartRight(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDPARTRIGHT, 0, 0);
	return TRUE;
}

int CSciContext::WordPartRightExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDPARTRIGHTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::SetVisiblePolicy(CValue** ppParams)
{
	int visiblePolicy=ppParams[0]->GetNumeric();
	int visibleSlop=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETVISIBLEPOLICY, visiblePolicy, visibleSlop);
	return TRUE;
}

int CSciContext::DelLineLeft(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_DELLINELEFT, 0, 0);
	return TRUE;
}

int CSciContext::DelLineRight(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_DELLINERIGHT, 0, 0);
	return TRUE;
}

int CSciContext::SetXOffset(CValue** ppParams)
{
	int newOffset=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETXOFFSET, newOffset, 0);
	return TRUE;
}

int CSciContext::GetXOffset(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETXOFFSET, 0, 0);
	return TRUE;
}

int CSciContext::ChooseCaretX(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CHOOSECARETX, 0, 0);
	return TRUE;
}

int CSciContext::GrabFocus(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_GRABFOCUS, 0, 0);
	return TRUE;
}

int CSciContext::SetXCaretPolicy(CValue** ppParams)
{
	int caretPolicy=ppParams[0]->GetNumeric();
	int caretSlop=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETXCARETPOLICY, caretPolicy, caretSlop);
	return TRUE;
}

int CSciContext::SetYCaretPolicy(CValue** ppParams)
{
	int caretPolicy=ppParams[0]->GetNumeric();
	int caretSlop=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETYCARETPOLICY, caretPolicy, caretSlop);
	return TRUE;
}

int CSciContext::SetPrintWrapMode(CValue** ppParams)
{
	int mode=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETPRINTWRAPMODE, mode, 0);
	return TRUE;
}

int CSciContext::GetPrintWrapMode(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETPRINTWRAPMODE, 0, 0);
	return TRUE;
}

int CSciContext::SetHotspotActiveFore(CValue** ppParams)
{
	BOOL useSetting=ppParams[0]->GetNumeric();
	COLORREF fore=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETHOTSPOTACTIVEFORE, useSetting, fore);
	return TRUE;
}

int CSciContext::GetHotspotActiveFore(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETHOTSPOTACTIVEFORE, 0, 0);
	return TRUE;
}

int CSciContext::SetHotspotActiveBack(CValue** ppParams)
{
	BOOL useSetting=ppParams[0]->GetNumeric();
	COLORREF back=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETHOTSPOTACTIVEBACK, useSetting, back);
	return TRUE;
}

int CSciContext::GetHotspotActiveBack(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETHOTSPOTACTIVEBACK, 0, 0);
	return TRUE;
}

int CSciContext::SetHotspotActiveUnderline(CValue** ppParams)
{
	BOOL underline=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETHOTSPOTACTIVEUNDERLINE, underline, 0);
	return TRUE;
}

int CSciContext::GetHotspotActiveUnderline(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETHOTSPOTACTIVEUNDERLINE, 0, 0);
	return TRUE;
}

int CSciContext::SetHotspotSingleLine(CValue** ppParams)
{
	BOOL singleLine=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETHOTSPOTSINGLELINE, singleLine, 0);
	return TRUE;
}

int CSciContext::GetHotspotSingleLine(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETHOTSPOTSINGLELINE, 0, 0);
	return TRUE;
}

int CSciContext::ParaDown(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_PARADOWN, 0, 0);
	return TRUE;
}

int CSciContext::ParaDownExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_PARADOWNEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::ParaUp(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_PARAUP, 0, 0);
	return TRUE;
}

int CSciContext::ParaUpExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_PARAUPEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::PositionBefore(CValue& retVal, CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_POSITIONBEFORE, pos, 0);
	return TRUE;
}

int CSciContext::PositionAfter(CValue& retVal, CValue** ppParams)
{
	long pos=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_POSITIONAFTER, pos, 0);
	return TRUE;
}

int CSciContext::CopyRange(CValue** ppParams)
{
	long start=ppParams[0]->GetNumeric();
	long end=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_COPYRANGE, start, end);
	return TRUE;
}

int CSciContext::CopyText(CValue** ppParams)
{
	int length=ppParams[0]->GetNumeric();
	const char* text=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_COPYTEXT, length, reinterpret_cast<LPARAM>(text));
	return TRUE;
}

int CSciContext::SetSelectionMode(CValue** ppParams)
{
	int mode=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETSELECTIONMODE, mode, 0);
	return TRUE;
}

int CSciContext::GetSelectionMode(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSELECTIONMODE, 0, 0);
	return TRUE;
}

int CSciContext::GetLineSelStartPosition(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLINESELSTARTPOSITION, line, 0);
	return TRUE;
}

int CSciContext::GetLineSelEndPosition(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLINESELENDPOSITION, line, 0);
	return TRUE;
}

int CSciContext::LineDownRectExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEDOWNRECTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::LineUpRectExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEUPRECTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::CharLeftRectExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CHARLEFTRECTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::CharRightRectExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_CHARRIGHTRECTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::HomeRectExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_HOMERECTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::VCHomeRectExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_VCHOMERECTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::LineEndRectExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_LINEENDRECTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::PageUpRectExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_PAGEUPRECTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::PageDownRectExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_PAGEDOWNRECTEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::StutteredPageUp(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_STUTTEREDPAGEUP, 0, 0);
	return TRUE;
}

int CSciContext::StutteredPageUpExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_STUTTEREDPAGEUPEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::StutteredPageDown(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_STUTTEREDPAGEDOWN, 0, 0);
	return TRUE;
}

int CSciContext::StutteredPageDownExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_STUTTEREDPAGEDOWNEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::WordLeftEnd(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDLEFTEND, 0, 0);
	return TRUE;
}

int CSciContext::WordLeftEndExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDLEFTENDEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::WordRightEnd(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDRIGHTEND, 0, 0);
	return TRUE;
}

int CSciContext::WordRightEndExtend(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_WORDRIGHTENDEXTEND, 0, 0);
	return TRUE;
}

int CSciContext::SetWhitespaceChars(CValue** ppParams)
{
	const char* characters=ppParams[0]->GetString();
	m_pSciCtrl->Call(SCI_SETWHITESPACECHARS, 0, reinterpret_cast<LPARAM>(characters));
	return TRUE;
}

int CSciContext::SetCharsDefault(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_SETCHARSDEFAULT, 0, 0);
	return TRUE;
}

int CSciContext::AutoCGetCurrent(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_AUTOCGETCURRENT, 0, 0);
	return TRUE;
}

int CSciContext::Allocate(CValue** ppParams)
{
	int bytes=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_ALLOCATE, bytes, 0);
	return TRUE;
}

int CSciContext::TargetAsUTF8(CValue& retVal, CValue** ppParams)
{
	const char* s=ppParams[0]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_TARGETASUTF8, 0, reinterpret_cast<LPARAM>(s));
	return TRUE;
}

int CSciContext::SetLengthForEncode(CValue** ppParams)
{
	int bytes=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETLENGTHFORENCODE, bytes, 0);
	return TRUE;
}

int CSciContext::EncodedFromUTF8(CValue& retVal, CValue** ppParams)
{
	const char* utf8=ppParams[0]->GetString();
	const char* encoded=ppParams[1]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_ENCODEDFROMUTF8, reinterpret_cast<WPARAM>(utf8), reinterpret_cast<LPARAM>(encoded));
	return TRUE;
}

int CSciContext::FindColumn(CValue& retVal, CValue** ppParams)
{
	int line=ppParams[0]->GetNumeric();
	int column=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_FINDCOLUMN, line, column);
	return TRUE;
}

int CSciContext::GetCaretSticky(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCARETSTICKY, 0, 0);
	return TRUE;
}

int CSciContext::SetCaretSticky(CValue** ppParams)
{
	BOOL useCaretStickyBehaviour=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCARETSTICKY, useCaretStickyBehaviour, 0);
	return TRUE;
}

int CSciContext::ToggleCaretSticky(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_TOGGLECARETSTICKY, 0, 0);
	return TRUE;
}

int CSciContext::SetPasteConvertEndings(CValue** ppParams)
{
	BOOL convert=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETPASTECONVERTENDINGS, convert, 0);
	return TRUE;
}

int CSciContext::GetPasteConvertEndings(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETPASTECONVERTENDINGS, 0, 0);
	return TRUE;
}

int CSciContext::SelectionDuplicate(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_SELECTIONDUPLICATE, 0, 0);
	return TRUE;
}

int CSciContext::SetCaretLineBackAlpha(CValue** ppParams)
{
	int alpha=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCARETLINEBACKALPHA, alpha, 0);
	return TRUE;
}

int CSciContext::GetCaretLineBackAlpha(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCARETLINEBACKALPHA, 0, 0);
	return TRUE;
}

int CSciContext::SetCaretStyle(CValue** ppParams)
{
	int caretStyle=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETCARETSTYLE, caretStyle, 0);
	return TRUE;
}

int CSciContext::GetCaretStyle(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETCARETSTYLE, 0, 0);
	return TRUE;
}

int CSciContext::SetIndicatorCurrent(CValue** ppParams)
{
	int indicator=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETINDICATORCURRENT, indicator, 0);
	return TRUE;
}

int CSciContext::GetIndicatorCurrent(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETINDICATORCURRENT, 0, 0);
	return TRUE;
}

int CSciContext::SetIndicatorValue(CValue** ppParams)
{
	int value=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETINDICATORVALUE, value, 0);
	return TRUE;
}

int CSciContext::GetIndicatorValue(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETINDICATORVALUE, 0, 0);
	return TRUE;
}

int CSciContext::IndicatorFillRange(CValue** ppParams)
{
	int position=ppParams[0]->GetNumeric();
	int fillLength=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_INDICATORFILLRANGE, position, fillLength);
	return TRUE;
}

int CSciContext::IndicatorClearRange(CValue** ppParams)
{
	int position=ppParams[0]->GetNumeric();
	int clearLength=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_INDICATORCLEARRANGE, position, clearLength);
	return TRUE;
}

int CSciContext::IndicatorAllOnFor(CValue& retVal, CValue** ppParams)
{
	int position=ppParams[0]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_INDICATORALLONFOR, position, 0);
	return TRUE;
}

int CSciContext::IndicatorValueAt(CValue& retVal, CValue** ppParams)
{
	int indicator=ppParams[0]->GetNumeric();
	int position=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_INDICATORVALUEAT, indicator, position);
	return TRUE;
}

int CSciContext::IndicatorStart(CValue& retVal, CValue** ppParams)
{
	int indicator=ppParams[0]->GetNumeric();
	int position=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_INDICATORSTART, indicator, position);
	return TRUE;
}

int CSciContext::IndicatorEnd(CValue& retVal, CValue** ppParams)
{
	int indicator=ppParams[0]->GetNumeric();
	int position=ppParams[1]->GetNumeric();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_INDICATOREND, indicator, position);
	return TRUE;
}

int CSciContext::SetPositionCache(CValue** ppParams)
{
	int size=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETPOSITIONCACHE, size, 0);
	return TRUE;
}

int CSciContext::GetPositionCache(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETPOSITIONCACHE, 0, 0);
	return TRUE;
}

int CSciContext::CopyAllowLine(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_COPYALLOWLINE, 0, 0);
	return TRUE;
}

int CSciContext::StartRecord(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_STARTRECORD, 0, 0);
	return TRUE;
}

int CSciContext::StopRecord(CValue** ppParams)
{
	m_pSciCtrl->Call(SCI_STOPRECORD, 0, 0);
	return TRUE;
}

int CSciContext::SetLexer(CValue** ppParams)
{
	int lexer=ppParams[0]->GetNumeric();
	m_pSciCtrl->Call(SCI_SETLEXER, lexer, 0);
	return TRUE;
}

int CSciContext::GetLexer(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETLEXER, 0, 0);
	return TRUE;
}

int CSciContext::Colourise(CValue** ppParams)
{
	long start=ppParams[0]->GetNumeric();
	long end=ppParams[1]->GetNumeric();
	m_pSciCtrl->Call(SCI_COLOURISE, start, end);
	return TRUE;
}

int CSciContext::SetProperty(CValue** ppParams)
{
	const char* key=ppParams[0]->GetString();
	const char* value=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_SETPROPERTY, reinterpret_cast<WPARAM>(key), reinterpret_cast<LPARAM>(value));
	return TRUE;
}

int CSciContext::SetKeyWords(CValue** ppParams)
{
	int keywordSet=ppParams[0]->GetNumeric();
	const char* keyWords=ppParams[1]->GetString();
	m_pSciCtrl->Call(SCI_SETKEYWORDS, keywordSet, reinterpret_cast<LPARAM>(keyWords));
	return TRUE;
}

int CSciContext::SetLexerLanguage(CValue** ppParams)
{
	const char* language=ppParams[0]->GetString();
	m_pSciCtrl->Call(SCI_SETLEXERLANGUAGE, 0, reinterpret_cast<LPARAM>(language));
	return TRUE;
}

int CSciContext::LoadLexerLibrary(CValue** ppParams)
{
	const char* path=ppParams[0]->GetString();
	m_pSciCtrl->Call(SCI_LOADLEXERLIBRARY, 0, reinterpret_cast<LPARAM>(path));
	return TRUE;
}



int CSciContext::GetPropertyInt(CValue& retVal, CValue** ppParams)
{
	const char* key=ppParams[0]->GetString();
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETPROPERTYINT, reinterpret_cast<WPARAM>(key), 0);
	return TRUE;
}

int CSciContext::GetStyleBitsNeeded(CValue& retVal, CValue** ppParams)
{
	retVal.SetType(CType(1));
	retVal.m_Number=m_pSciCtrl->Call(SCI_GETSTYLEBITSNEEDED, 0, 0);
	return TRUE;
}

